shared source/wpf/src/host/shimimpl/classfactory.cxx

   1 //+-----------------------------------------------------------------------
   2 //
   3 //  Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 //  Description:
   6 //     Implements the ClassFactory of PresentationHost.
   7 //
   8 // History:
   9 //      2002/06/12-murrayw
  10 //          Created
  11 //      2007/09/20-[....]
  12 //          Ported Windows->DevDiv. See SourcesHistory.txt.
  13 //
  14 //------------------------------------------------------------------------
  15
  16 #include "Precompiled.hxx"
  17 #include "ClassFactory.hxx"
  18 #include "HostShim.hxx"
  19 #include "Main.hxx"
  20
  21 DWORD CClassFactory::s_dwRegistrationToken[] = {0,0};
  22 LPCLSID CClassFactory::s_clsIdActivated = NULL;
  23
  24 //******************************************************************************
  25 //
  26 //   CClassFactory::CClassFactory
  27 //
  28 //******************************************************************************
  29
  30 CClassFactory::CClassFactory(__in REFCLSID clsId)
  31     : m_clsId(clsId)
  32 {
  33     m_ObjRefCount = 0;
  34 }
  35
  36 //******************************************************************************
  37 //
  38 //   CClassFactory::~CClassFactory
  39 //
  40 //******************************************************************************
  41
  42 CClassFactory::~CClassFactory()
  43 {
  44 }
  45
  46
  47 //******************************************************************************
  48 //
  49 // CClassFactory::RegisterClassObjects
  50 //
  51 // This method creates ClassFactory objects and registers their objects based
  52 // on the flags. We don't hold on to the factories; OLE has them, and when
  53 // we Revoke them, OLE will Release them and they will be deleted.
  54 //******************************************************************************
  55
  56 HRESULT CClassFactory::RegisterClassObjects()
  57 {
  58     HRESULT hr = S_OK;
  59
  60     ASSERT(s_dwRegistrationToken[0] == 0);
  61     ASSERT(s_dwRegistrationToken[1] == 0);
  62
  63 #ifdef DOCUMENT_SHIM
  64     CClassFactory* pFactory = new CClassFactory(CLSID_DocObjPackage);
  65     CK_ALLOC(pFactory);
  66     CKHR(pFactory->RegisterClassObject(s_dwRegistrationToken[0]));
  67 #endif
  68
  69 #ifdef APPLICATION_SHIM
  70     CClassFactory* pFactory = new CClassFactory(CLSID_DocObjXaml);
  71     CK_ALLOC(pFactory);
  72     CKHR(pFactory->RegisterClassObject(s_dwRegistrationToken[0]));
  73
  74     pFactory = new CClassFactory(CLSID_DocObjXapp);
  75     CK_ALLOC(pFactory);
  76     CKHR(pFactory->RegisterClassObject(s_dwRegistrationToken[1]));
  77 #endif
  78
  79 Cleanup:
  80     if (hr != S_OK)
  81     {
  82         CClassFactory::RevokeAllClassObjects();
  83     }
  84
  85     return hr;
  86 }
  87
  88 //******************************************************************************
  89 //
  90 // CClassFactory::RevokeAllClassObjects
  91 //
  92 // Revoke any registered ClassObjects, and delete the ClassFactories.
  93 // This doesn't check any return values, nor does it return anything,
  94 // because this is a cleanup step, and if it fails, it really isn't
  95 // actionable.
  96 //******************************************************************************
  97
  98 void CClassFactory::RevokeAllClassObjects()
  99 {
 100     for (UINT tokenIndex = 0; tokenIndex < MAX_TOKENS; ++tokenIndex)
 101     {
 102         if (s_dwRegistrationToken[tokenIndex])
 103         {
 104             CoRevokeClassObject(s_dwRegistrationToken[tokenIndex]);
 105             s_dwRegistrationToken[tokenIndex] = 0;
 106         }
 107     }
 108 }
 109
 110 //******************************************************************************
 111 //
 112 //  CClassFactory::RegisterClassObject
 113 //
 114 //  This method registers the ClsObject that this is offering.
 115 //******************************************************************************
 116
 117 HRESULT CClassFactory::RegisterClassObject(DWORD& dwRegistrationToken)
 118 {
 119     HRESULT hr = S_OK;
 120
 121     LPUNKNOWN pUnknown = reinterpret_cast<LPUNKNOWN> (this);
 122
 123     //register the MIME-type handler class object
 124     CKHR(CoRegisterClassObject(m_clsId,
 125                                pUnknown,
 126                                CLSCTX_LOCAL_SERVER,
 127                                REGCLS_SINGLEUSE,
 128                                &dwRegistrationToken));
 129 Cleanup:
 130     if (hr != S_OK && dwRegistrationToken)
 131     {
 132         CoRevokeClassObject(dwRegistrationToken);
 133         dwRegistrationToken = 0;
 134     }
 135     return hr;
 136 }
 137
 138 //******************************************************************************
 139 //
 140 //  CClassFactory::QueryInterface
 141 //
 142 //******************************************************************************
 143
 144 STDMETHODIMP CClassFactory::QueryInterface(REFIID riid,
 145                                            __out LPVOID *ppReturn)
 146 {
 147     HRESULT hr = S_OK;
 148
 149     CK_PARG(ppReturn);
 150
 151     if (IsEqualIID(riid, IID_IUnknown))
 152     {
 153         *ppReturn = reinterpret_cast<LPUNKNOWN>
 154                        (reinterpret_cast<LPCLASSFACTORY>(this));
 155
 156         m_ObjRefCount++;
 157     }
 158     else if (IsEqualIID(riid, IID_IClassFactory))
 159     {
 160         *ppReturn = reinterpret_cast<LPCLASSFACTORY>(this);
 161         m_ObjRefCount++;
 162     }
 163     else
 164     {
 165         *ppReturn = NULL;
 166         hr = E_NOINTERFACE;
 167     }
 168
 169 Cleanup:
 170
 171     return hr;
 172 }
 173
 174 //******************************************************************************
 175 //
 176 //   CClassFactory::AddRef
 177 //
 178 //******************************************************************************
 179
 180 STDMETHODIMP_(DWORD) CClassFactory::AddRef()
 181 {
 182     return ++m_ObjRefCount;
 183 }
 184
 185 //******************************************************************************
 186 //
 187 //   CClassFactory::Release
 188 //
 189 //******************************************************************************
 190
 191 STDMETHODIMP_(DWORD) CClassFactory::Release()
 192 {
 193     if (--m_ObjRefCount == 0)
 194     {
 195         delete this;
 196         return 0;
 197     }
 198
 199     return m_ObjRefCount;
 200 }
 201
 202 //******************************************************************************
 203 //
 204 //   CClassFactory::CreateInstance
 205 //
 206 //******************************************************************************
 207
 208 STDMETHODIMP CClassFactory::CreateInstance(__in LPUNKNOWN pUnknown,
 209                                            REFIID riid,
 210                                            __out LPVOID *ppObject)
 211 {
 212     EventWriteWpfHostUm_ClassFactoryCreateInstance();
 213
 214     HRESULT hr = S_OK;
 215     CHostShim * pHostShim = NULL;
 216
 217     CK_PARG(ppObject);
 218
 219     *ppObject = NULL;
 220
 221     if (pUnknown != NULL)
 222     {
 223         hr = CLASS_E_NOAGGREGATION;
 224         goto Cleanup;
 225     }
 226
 227     pHostShim = new CHostShim();
 228     CK_ALLOC(pHostShim);
 229
 230     CKHR(pHostShim->QueryInterface(riid, ppObject));
 231
 232     SetActivatedClsId(m_clsId);
 233
 234 Cleanup:
 235
 236     if (FAILED(hr))
 237     {
 238         DEL_PTR(pHostShim);
 239     }
 240
 241     // Revoke any class factories that may have been created.
 242     // Current implementation only creates one.
 243     CClassFactory::RevokeAllClassObjects();
 244
 245     return hr;
 246 }
 247
 248 //******************************************************************************
 249 //
 250 //   CClassFactory::LockServer
 251 //
 252 //******************************************************************************
 253
 254 STDMETHODIMP CClassFactory::LockServer(BOOL fLock)
 255 {
 256     HRESULT hr = S_OK;
 257
 258     if (fLock)
 259     {
 260         InterlockedIncrement(&g_ServerRefCount);
 261     }
 262     else
 263     {
 264         InterlockedDecrement(&g_ServerRefCount);
 265
 266         if (g_ServerRefCount <= 0)
 267         {
 268             PostQuitMessage(ERROR_SUCCESS);
 269         }
 270     }
 271
 272     return hr;
 273 }
 274